CREATE TABLE ALUMNO
(
		IDALUMNO 		NUMBER(8),
		CURP 			VARCHAR2(18) 	CONSTRAINT CURP_NN   NOT NULL,
		NOMBREALU		VARCHAR2(55) 	CONSTRAINT ALUMPM_NN NOT NULL,
		APELLIDOP		VARCHAR2(45) 	CONSTRAINT ALUMPA_NN NOT NULL,
		APELLIDOM		VARCHAR2(45) 	CONSTRAINT ALUMSA_NN NOT NULL,
		SEXO			CHAR 			CONSTRAINT SEXO_ANN	 NOT NULL,
		FECHANAC		DATE		 	CONSTRAINT FECHANAC_NN  NOT NULL,
		ESTADO		    VARCHAR2(45)    CONSTRAINT ESTADO_NN 	NOT NULL,
		MUNICIPIO 		VARCHAR2(45) 	CONSTRAINT MUNICIPIO_NN NOT NULL,
		RFC 			CHAR(13),
		CONSTRAINT IDALUMNO_PK PRIMARY KEY (IDALUMNO),
		CONSTRAINT SEXO_A CHECK(SEXO IN ('M','H'))
);

CREATE TABLE RESPONSABLE
(
		IDRESPONSABLE 	NUMBER(8),
		NOMBRERESP	 	VARCHAR2(55) 	CONSTRAINT NOMBRERESP_NN NOT NULL,
		APELLIDOP 		VARCHAR2(45)	CONSTRAINT RESPONPA_NN 	 NOT NULL,
		APELLIDOM 		VARCHAR2(45) 	CONSTRAINT RESPONSA_NN 	 NOT NULL,
		SEXO 			CHAR 			CONSTRAINT SEXO_RNN 	 NOT NULL,
		EDAD 			NUMBER(2) 		CONSTRAINT EDAD_RNN 	 NOT NULL,
		PARENTESCO 		VARCHAR2(45)	CONSTRAINT PARENTESCO_NN NOT NULL,
		CALLE 			VARCHAR2(45) 	CONSTRAINT CALLE_NN 	 NOT NULL,
		COLONIA 		VARCHAR2(45) 	CONSTRAINT COLONIA_NN 	 NOT NULL,
		NUMERO 			NUMBER(6) 		CONSTRAINT NUMERO_NN 	 NOT NULL,
		MOVIL 			NUMBER(15),
		CONSTRAINT IDRESPONSABLE_PK PRIMARY KEY(IDRESPONSABLE),
		CONSTRAINT SEXO_R CHECK(SEXO IN ('M','H')),
		CONSTRAINT EDAD_RRANGO CHECK(EDAD<50 AND EDAD>15)		
);

CREATE TABLE TELEFONOHORARIO
(
		IDRESPONSABLE 	NUMBER(8),
		TELEFONO 		NUMBER(10) 		CONSTRAINT TELEFONO_NN NOT NULL,
		HORARIO 		VARCHAR2(45) 	CONSTRAINT HORARIO_NN  NOT NULL,
		CONSTRAINT TIDRESPONSABLE_FK FOREIGN KEY(IDRESPONSABLE) REFERENCES RESPONSABLE ON DELETE CASCADE
);


CREATE TABLE ALUMNO_RESPONSABLE
(
	IDALUMNO			NUMBER(8),
	IDRESPONSABLE 		NUMBER(8),
	CONSTRAINT IDALUMNO_FK FOREIGN KEY(IDALUMNO) REFERENCES ALUMNO,
	CONSTRAINT A_RIDRESPONSABLE_FK FOREIGN KEY(IDRESPONSABLE) REFERENCES RESPONSABLE ON DELETE SET NULL,
	CONSTRAINT ALU_RES_UNIQUE UNIQUE(IDALUMNO,IDRESPONSABLE)
);

CREATE TABLE TUTOR
(
		RFC 			CHAR(13),
		IDRESPONSABLE 	NUMBER(8) CONSTRAINT T_IDRESPONSABLE_NN NOT NULL,
		CONSTRAINT RFC_PK PRIMARY KEY(RFC),
		CONSTRAINT TUTORIDRESPONSABLE_FK FOREIGN KEY(IDRESPONSABLE) REFERENCES RESPONSABLE ON DELETE CASCADE
);

ALTER TABLE ALUMNO ADD CONSTRAINT ARFC_FK  FOREIGN KEY(RFC) REFERENCES TUTOR;

CREATE TABLE  INSCRIPCION
(
		IDINSCRIPCION 		NUMBER(8),
		CICLOESCOLAR 		VARCHAR2(20) 	CONSTRAINT CICLOESCOLAR_NN NOT NULL,
		FECHAINSCRIPCION 	DATE 			CONSTRAINT FECHAINSCRIPCION_NN NOT NULL,
		IDALUMNO 			NUMBER(8)		CONSTRAINT I_IDALUMNO_NN NOT NULL,
		IDNIVEL 		NUMBER(8)			CONSTRAINT I_IDNIVEL_NN 	NOT NULL,
		IDGRADO			NUMBER(8)			CONSTRAINT I_IDGRADO_NN 	NOT NULL,
		CONSTRAINT IDINSCRIPCION_PK PRIMARY KEY(IDINSCRIPCION)
);


ALTER TABLE INSCRIPCION ADD CONSTRAINT IIDALUMNO_FK FOREIGN KEY(IDALUMNO) REFERENCES ALUMNO; 

CREATE TABLE NIVEL
(
		IDNIVEL 		NUMBER(8),
		NIVEL			VARCHAR2(20) 		CONSTRAINT NIVEL_NN NOT NULL,
		CONSTRAINT IDNIVEL_PK PRIMARY KEY(IDNIVEL),
		CONSTRAINT NIVELES_UNICOS UNIQUE(NIVEL)
);

CREATE TABLE NIVEL_GRADO
(
		IDNIVEL 		NUMBER(8),
		IDGRADO			NUMBER(8)		CONSTRAINT IDGRADO_NN 	NOT NULL,
		CONSTRAINT IDNIVEL_FK FOREIGN KEY(IDNIVEL) REFERENCES NIVEL,
		CONSTRAINT NIVEL_GRADO_PK PRIMARY KEY(IDNIVEL,IDGRADO)
);

ALTER TABLE INSCRIPCION ADD CONSTRAINT I_IDNIVEL_GRADO_FK FOREIGN KEY(IDNIVEL,IDGRADO) REFERENCES NIVEL_GRADO; 

CREATE TABLE GRUPO
(
		IDGRUPO 		NUMBER(8),
		GRUPO 			VARCHAR2(3) 	CONSTRAINT GRUPO_NN 	NOT NULL,
		IDNIVEL 		NUMBER(8)		CONSTRAINT GIDNIVEL_NN 	NOT NULL,
		IDGRADO			NUMBER(8)		CONSTRAINT GIDGRADO_NN 	NOT NULL,
		CONSTRAINT NIVGRAD_GPO FOREIGN KEY(IDNIVEL,IDGRADO) REFERENCES NIVEL_GRADO,
		CONSTRAINT IDGRUPO_PK 	PRIMARY KEY(IDGRUPO)
);

--EL CONSTRAINT SRVC_TIPO_U ES PARA QUE NO REPITA SERVICIOS AL INSERTAR
CREATE TABLE SERVICIO
(
		IDSERVICIO 		NUMBER(8),
		TIPO 			VARCHAR2(45	)	CONSTRAINT TIPO_NN 			NOT NULL,
		CONSTRAINT SRVC_TIPO UNIQUE(TIPO),
		CONSTRAINT IDSERVICIO_PK 	PRIMARY KEY(IDSERVICIO)
);

CREATE TABLE GRADO_SERVICIO
(
		PRECIO 			NUMBER(12,2) 	CONSTRAINT PRECIO_NN 		NOT NULL,
		IDNIVEL 		NUMBER(8)		CONSTRAINT GSIDNIVEL_NN 	NOT NULL,
		IDGRADO 		NUMBER(8)		CONSTRAINT GSIDGRADO_NN 	NOT NULL,
		IDSERVICIO 		NUMBER(8)		CONSTRAINT GSIDSERVICIO_NN 	NOT NULL,
		CONSTRAINT GS_U UNIQUE(PRECIO,IDNIVEL,IDGRADO,IDSERVICIO),
		CONSTRAINT GRAD_SRVCE_FK FOREIGN KEY(IDNIVEL,IDGRADO) REFERENCES NIVEL_GRADO,
		CONSTRAINT GS_SRVCE_FK FOREIGN KEY(IDSERVICIO) REFERENCES SERVICIO
);


CREATE TABLE CARGO
(
	IDCARGO		NUMBER(8),
	FECHACARGO 	DATE  	CONSTRAINT FECHACARGO_NN 	NOT NULL,
	FECHAVEN 	DATE  	CONSTRAINT FECHAVEN_NN 		NOT NULL,
	FECHAPAGO 	DATE,
	IMPORTE 	NUMBER(12,2) CONSTRAINT IMPORTE_NN 	NOT NULL,
	NUMERO_PAGOS NUMBER(2) CONSTRAINT NUMERO_PAGOS_NN NOT NULL,
	PAGO 		 NUMBER(3),
	ABONO 		NUMBER(12,2) DEFAULT 0,
	CVS 		CHAR(2),
	CARGO 		NUMBER(8),
	IDINSCRIPCION NUMBER(8) CONSTRAINT C_IDINSCRIPCION_NN 	NOT NULL,
	IDSERVICIO    NUMBER(8) CONSTRAINT C_IDSERVICIO_NN 	NOT NULL,
	CONSTRAINT IDCARGO_PK PRIMARY KEY(IDCARGO),
	CONSTRAINT C_INSCRIP_FK FOREIGN KEY(IDINSCRIPCION) REFERENCES INSCRIPCION,
	CONSTRAINT C_SRVCE_FK FOREIGN KEY(IDSERVICIO) REFERENCES SERVICIO
);

CREATE TABLE DESCUENTO
(
	IDDESCUENTO 	NUMBER(8),
	FECHADESC 		DATE 			CONSTRAINT FECHADESC_NN NOT NULL,
	IMPORTE 		NUMBER(12,2) 	CONSTRAINT IMPORTE_D_NN NOT NULL,
	APLICADO 		CHAR(2) 		DEFAULT 'NO',
	IDCARGO 		NUMBER(8) 		CONSTRAINT CARGO_NN NOT NULL,
	CARGOAPLICADO   NUMBER(8),
	REMUNERADO	CHAR(2)				DEFAULT 'NO',
	CONSTRAINT IDDESCUENTO_PK PRIMARY KEY(IDDESCUENTO),
	CONSTRAINT CARGOAPLICADO_FK FOREIGN KEY(CARGOAPLICADO) REFERENCES CARGO(IDCARGO),
	CONSTRAINT IDCARGO_FK FOREIGN KEY(IDCARGO) REFERENCES CARGO(IDCARGO)
);

--PROCEDURES
--SERVICIO
CREATE SEQUENCE AUTO_IDSERVICIO INCREMENT BY 1 MINVALUE 10000001;

CREATE OR REPLACE PROCEDURE ALTA_SERVCIO(VTIPO IN VARCHAR2)
AS
	VTIPO_ACTUAL VARCHAR2(45);
BEGIN
		SELECT TIPO INTO VTIPO_ACTUAL FROM SERVICIO
		WHERE TIPO=VTIPO;
		IF (VTIPO_ACTUAL IS NOT NULL) THEN
			DBMS_OUTPUT.PUT_LINE('EL SERVICIO YA EXISTE, NO PUEDE SER DUPLICADO');
		END IF;
		EXCEPTION
		WHEN NO_DATA_FOUND THEN
			INSERT INTO SERVICIO(IDSERVICIO,TIPO)VALUES(AUTO_IDSERVICIO.NEXTVAL,VTIPO);
			DBMS_OUTPUT.PUT_LINE('SE HA INGRESADO EL SERVICIO: '||VTIPO);	
			COMMIT;	
END ALTA_SERVCIO;
/

CREATE OR REPLACE PROCEDURE BAJA_SERVCIO(VIDSERVICIO IN NUMBER)
AS
BEGIN
	DELETE FROM SERVICIO WHERE IDSERVICIO=VIDSERVICIO;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO SE ELIMINÓ SERVICIO ALGUNO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('HA SIDO ELIMINADO EL SERVICIO');
		COMMIT;
	END IF;
END BAJA_SERVCIO;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_SERVCIO(VIDSERVICIO IN NUMBER,VTIPO IN VARCHAR2)
AS
BEGIN
	UPDATE SERVICIO SET TIPO=VTIPO WHERE IDSERVICIO=VIDSERVICIO;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL SERVICIO A ACTUALIZAR');
	ELSE
		DBMS_OUTPUT.PUT_LINE('SE ACTUALIZÓ EL SERVICIO');
		COMMIT;
	END IF;
END ACTUALIZA_SERVCIO;
/
--/SERVICIO
--NIVEL
CREATE SEQUENCE AUTO_IDNIVEL INCREMENT BY 1 MINVALUE 10000001;

CREATE OR REPLACE PROCEDURE ALTA_NIVEL(NIVEL$ IN VARCHAR2)
AS
	NIVEL_ACTUAL$ 	VARCHAR2(45);
BEGIN
	SELECT NIVEL INTO NIVEL_ACTUAL$ FROM NIVEL 
	WHERE NIVEL=NIVEL$;
	IF(NIVEL_ACTUAL$ IS NOT NULL) THEN
		DBMS_OUTPUT.PUT_LINE('EL SERVICIO YA EXISTE, NO PUEDE SER DUPLICADO');
	END IF;
	EXCEPTION
	WHEN NO_DATA_FOUND THEN
		INSERT INTO NIVEL(IDNIVEL,NIVEL) VALUES(AUTO_IDNIVEL.NEXTVAL,NIVEL$);
		DBMS_OUTPUT.PUT_LINE('SE HA AGREGADO EL NIVEL:'||NIVEL$);
		COMMIT;
END ALTA_NIVEL;
/

CREATE OR REPLACE PROCEDURE BAJA_NIVEL(IDNIVEL$ IN NUMBER)
AS
BEGIN
	DELETE FROM NIVEL WHERE IDNIVEL=IDNIVEL$;
	IF SQL%NOTFOUND THEN 
		DBMS_OUTPUT.PUT_LINE('NO SE ELIMINO EL NIVEL');
	ELSE
		DBMS_OUTPUT.PUT_LINE('SE ELIMINO EL NIVEL');
	COMMIT;
	END IF;
END BAJA_NIVEL;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_NIVEL(IDNIVEL$ IN NUMBER,NIVEL$ IN VARCHAR2)
AS
BEGIN
	UPDATE NIVEL SET NIVEL=NIVEL$ WHERE IDNIVEL=IDNIVEL$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL NIVEL A ACTUALIZAR');
	ELSE
		DBMS_OUTPUT.PUT_LINE('SE ACTUALIZO EL NIVEL');
		COMMIT;
	END IF;
END ACTUALIZA_NIVEL;
/
--/NIVEL
--NIVEL_GRADO(GRADO)
CREATE OR REPLACE PROCEDURE ALTA_GRADO(IDNIVEL$ IN NUMBER,IDGRADO$ IN NUMBER)
AS
	NIVEL$		VARCHAR2(45); 	
BEGIN
	INSERT INTO NIVEL_GRADO(IDNIVEL,IDGRADO) VALUES(IDNIVEL$,IDGRADO$);
	EXCEPTION
    WHEN DUP_VAL_ON_INDEX THEN
    	SELECT NIVEL INTO NIVEL$ FROM NIVEL WHERE IDNIVEL=IDNIVEL$;
    	DBMS_OUTPUT.PUT_LINE('EL GRADO: '||IDGRADO$||' EN '||IDNIVEL$||'('||NIVEL$||') YA EXISTE');
END ALTA_GRADO;
/

CREATE OR REPLACE PROCEDURE BAJA_GRADO(IDNIVEL$ IN NUMBER,IDGRADO$ NUMBER)
AS
BEGIN
	DELETE FROM NIVEL_GRADO WHERE IDNIVEL=IDNIVEL$ AND IDGRADO=IDGRADO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('EL GRADO NO EXISTE');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL GRADO SE ELIMINO');
	END IF;
	COMMIT;
END BAJA_GRADO;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_GRADO(IDNIVEL$ IN NUMBER,IDGRADO$ IN NUMBER,NUEVO_IDGRADO$ IN NUMBER)
AS
BEGIN
	UPDATE NIVEL_GRADO SET IDGRADO=NUEVO_IDGRADO$ WHERE IDNIVEL=IDNIVEL$ AND IDGRADO=IDGRADO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL NIVEL A ACTUALIZAR');
	ELSE
		DBMS_OUTPUT.PUT_LINE('SE ACTUALIZO EL NIVEL');
		COMMIT;
	END IF;
END ACTUALIZA_GRADO;
/
--/NIVEL_GRADO(GRADO)
--GRUPO
CREATE SEQUENCE AUTO_IDGRUPO INCREMENT BY 1 MINVALUE 10000001;

CREATE OR REPLACE PROCEDURE ALTA_GRUPO(GRUPO$ IN VARCHAR2,IDNIVEL$ IN NUMBER,IDGRADO$ IN NUMBER)
AS
	GRUPO_ACTUAL$ 		VARCHAR2(3);
	NIVEL_ACTUAL$ 		VARCHAR2(45);
BEGIN 
	SELECT GRUPO INTO GRUPO_ACTUAL$ FROM GRUPO 	WHERE GRUPO=GRUPO$ AND IDNIVEL=IDNIVEL$ AND IDGRADO=IDGRADO$;
	SELECT NIVEL INTO NIVEL_ACTUAL$ FROM NIVEL  WHERE IDNIVEL=IDNIVEL$;
	IF (GRUPO_ACTUAL$ IS NOT NULL) THEN
			DBMS_OUTPUT.PUT_LINE('EL GRUPO '||GRUPO$||' EN '||IDNIVEL$||'('||NIVEL_ACTUAL$||') Y EL GRADO '||IDGRADO$||' YA EXISTE, NO PUEDE SER DUPLICADO');
	END IF;
	EXCEPTION
	WHEN NO_DATA_FOUND THEN
	INSERT INTO GRUPO(IDGRUPO,GRUPO,IDNIVEL,IDGRADO) VALUES(AUTO_IDGRUPO.NEXTVAL,GRUPO$,IDNIVEL$,IDGRADO$);
	DBMS_OUTPUT.PUT_LINE('EL GRUPO FUE AGREGADO');
	COMMIT;
END  ALTA_GRUPO;
/

CREATE OR REPLACE PROCEDURE BAJA_GRUPO(IDGRUPO$ IN NUMBER)
AS
BEGIN
	DELETE FROM GRUPO WHERE IDGRUPO=IDGRUPO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('EL GRUPO NO EXISTE');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL GRUPO HA SIDO ELIMINADO');
		COMMIT;
	END IF;
END BAJA_GRUPO;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_GRUPO(IDGRUPO$ IN NUMBER,GRUPO$ IN VARCHAR2)
AS
BEGIN
	UPDATE GRUPO SET GRUPO=GRUPO$ WHERE IDGRUPO=IDGRUPO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL GRUPO A ACTUALIZAR');
	ELSE
		DBMS_OUTPUT.PUT_LINE('SE ACTUALIZO EL GRUPO');
	END IF;
	COMMIT;
END ACTUALIZA_GRUPO;
/

--/GRUPO

--GRADO_SERVICIO
CREATE OR REPLACE PROCEDURE ALTA_GRADO_SERVICIO(PRECIO$ IN NUMBER,IDNIVEL$ IN NUMBER,IDGRADO$ IN NUMBER,IDSERVICIO$ IN NUMBER)
AS 
	PRECIO_ACTUAL$ 	NUMBER(11,2);
	REGS_NIVELGRADO$ NUMBER(8);
	REGS_SERVICIO$ NUMBER(8);
BEGIN
	SELECT COUNT(*) INTO REGS_NIVELGRADO$ FROM NIVEL_GRADO;
	SELECT COUNT(*) INTO REGS_SERVICIO$ FROM SERVICIO;
	IF (REGS_NIVELGRADO$ > 0) AND (REGS_SERVICIO$ > 0) THEN
		SELECT PRECIO INTO PRECIO_ACTUAL$ FROM GRADO_SERVICIO WHERE IDNIVEL=IDNIVEL$ AND IDGRADO=IDGRADO$ AND IDSERVICIO=IDSERVICIO$;
		IF(PRECIO_ACTUAL$ IS NOT NULL) THEN
				DBMS_OUTPUT.PUT_LINE('EL PRECIO PARA '||IDSERVICIO$||' EN '||IDGRADO$||' NIVEL ('||IDNIVEL$||') YA EXISTE');
		END IF;
	ELSE
		DBMS_OUTPUT.PUT_LINE('NO HAY REGISTROS PADRES EN TABLA NIVEL_GRADO');
	END IF;

	EXCEPTION
	WHEN NO_DATA_FOUND THEN
		INSERT INTO GRADO_SERVICIO(PRECIO,IDNIVEL,IDGRADO,IDSERVICIO) VALUES(PRECIO$,IDNIVEL$,IDGRADO$,IDSERVICIO$);
		DBMS_OUTPUT.PUT_LINE('SE AGREGO EL PRECIO');
		COMMIT;
END ALTA_GRADO_SERVICIO;
/

CREATE OR REPLACE PROCEDURE BAJA_GRADO_SERVICIO(VIDNIVEL IN NUMBER,VIDGRADO IN NUMBER,VIDSERVICIO IN NUMBER)
AS
BEGIN
	DELETE FROM GRADO_SERVICIO WHERE IDNIVEL=VIDNIVEL AND IDGRADO=VIDGRADO AND IDSERVICIO=VIDSERVICIO;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO SE ELIMINÓ GRADO_SERVICIO ALGUNO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('HA SIDO ELIMINADO EL GRADO_SERVICIO');
		COMMIT;
	END IF;
END BAJA_GRADO_SERVICIO;
/


CREATE OR REPLACE PROCEDURE ACTUALIZA_GRADO_SERVICIO(VIDNIVEL IN NUMBER,VIDGRADO IN NUMBER,VIDSERVICIO IN NUMBER,VPRECIO IN NUMBER)
AS
BEGIN
	UPDATE GRADO_SERVICIO SET PRECIO=VPRECIO
		WHERE IDNIVEL=VIDNIVEL AND IDGRADO=VIDGRADO AND IDSERVICIO=VIDSERVICIO;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL SERVICIO A ACTUALIZAR');
	ELSE
		DBMS_OUTPUT.PUT_LINE('SE ACTUALIZÓ EL SERVICIO');
		COMMIT;
	END IF;
END ACTUALIZA_GRADO_SERVICIO;
/
--/GRADO_SERVICIO
DROP SEQUENCE AUTO_IDSERVICIO;
DROP SEQUENCE AUTO_IDGRUPO;
DROP SEQUENCE AUTO_IDNIVEL;

CREATE SEQUENCE AUTO_IDSERVICIO INCREMENT BY 1 MINVALUE 10000001;
CREATE SEQUENCE AUTO_IDGRUPO INCREMENT BY 1 MINVALUE 10000001;
CREATE SEQUENCE AUTO_IDNIVEL INCREMENT BY 1 MINVALUE 10000001;

EXEC ALTA_SERVCIO('COLEGIATURA');
EXEC ALTA_SERVCIO('INSCRIPCION');
EXEC ALTA_SERVCIO('MATERIAL ESCOLAR');
EXEC ALTA_SERVCIO('UNIFORME');
EXEC ALTA_SERVCIO('LIBROS');
EXEC ALTA_SERVCIO('SEGURO MEDICO');
EXEC ALTA_SERVCIO('TRANSPORTE');

--NIVEL
EXEC ALTA_NIVEL('PREESCOLAR');
EXEC ALTA_NIVEL('PRIMARIA');
EXEC ALTA_NIVEL('SECUNDARIA');
EXEC ALTA_NIVEL('PREPARATORIA');
--/NIVEL
--NIVEL_GRADO
--PREESCOLAR
EXEC ALTA_GRADO(10000001,1);
EXEC ALTA_GRADO(10000001,2);
--PRIMARIA
EXEC ALTA_GRADO(10000002,1);
EXEC ALTA_GRADO(10000002,2);
EXEC ALTA_GRADO(10000002,3);
EXEC ALTA_GRADO(10000002,4);
EXEC ALTA_GRADO(10000002,5);
EXEC ALTA_GRADO(10000002,6);
--SECUNDARIA
EXEC ALTA_GRADO(10000003,1);
EXEC ALTA_GRADO(10000003,2);
EXEC ALTA_GRADO(10000003,3);
--PREPARATORIA
EXEC ALTA_GRADO(10000004,1);
EXEC ALTA_GRADO(10000004,2);
EXEC ALTA_GRADO(10000004,3);
--/NIVEL_GRADO

--GRUPO
--GRUPO A,B DE PREESCOLAR 1
EXEC ALTA_GRUPO('A',10000001,1);
EXEC ALTA_GRUPO('B',10000001,1);
--GRUPOS A,B DE PREESCOLAR 2
EXEC ALTA_GRUPO('A',10000001,2);
EXEC ALTA_GRUPO('B',10000001,2);
--GRUPOS A DE PRIMARIA 
EXEC ALTA_GRUPO('A',10000002,1);
EXEC ALTA_GRUPO('A',10000002,2);
EXEC ALTA_GRUPO('A',10000002,3);
EXEC ALTA_GRUPO('A',10000002,4);
EXEC ALTA_GRUPO('A',10000002,5);
EXEC ALTA_GRUPO('A',10000002,6);
--GRUPOS B DE PRIMARIA
EXEC ALTA_GRUPO('B',10000002,1);
EXEC ALTA_GRUPO('B',10000002,2);
EXEC ALTA_GRUPO('B',10000002,3);
EXEC ALTA_GRUPO('B',10000002,4);
EXEC ALTA_GRUPO('B',10000002,5);
EXEC ALTA_GRUPO('B',10000002,6);

--GRUPOS A,B DE SECUNDARIA PRIMER AÑO
EXEC ALTA_GRUPO('A',10000003,1);
EXEC ALTA_GRUPO('B',10000003,1);

--GRUPOS A,B DE SECUNDARIA SEGUNDO AÑO
EXEC ALTA_GRUPO('A',10000003,2);
EXEC ALTA_GRUPO('B',10000003,2);

--GRUPOS A,B DE SECUNDARIA TERCER AÑO
EXEC ALTA_GRUPO('A',10000003,3);
EXEC ALTA_GRUPO('B',10000003,3);

--GRUPOS DE PREPARATORIA
--GRUPOS A,B DE PRIMERO
EXEC ALTA_GRUPO('A',10000004,1);
EXEC ALTA_GRUPO('B',10000004,1);
EXEC ALTA_GRUPO('C',10000004,1);

--GRUPOS A,B DE SEGUNDO
EXEC ALTA_GRUPO('A',10000004,2);
EXEC ALTA_GRUPO('B',10000004,2);
EXEC ALTA_GRUPO('C',10000004,2);

--GRUPOS A,B DE TERCERO
EXEC ALTA_GRUPO('A',10000004,3);
EXEC ALTA_GRUPO('B',10000004,3);
EXEC ALTA_GRUPO('C',10000004,3);

--/GRUPO

--GRADO_SERVICIO
--PREESCOLAR
EXEC ALTA_GRADO_SERVICIO(72000,10000001,1,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000001,1,10000002);
EXEC ALTA_GRADO_SERVICIO(2500,10000001,1,10000003);
EXEC ALTA_GRADO_SERVICIO(1000,10000001,1,10000004);
EXEC ALTA_GRADO_SERVICIO(2000,10000001,1,10000005);
EXEC ALTA_GRADO_SERVICIO(1000,10000001,1,10000006);
EXEC ALTA_GRADO_SERVICIO(340,10000001,1,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000001,2,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000001,2,10000002);
EXEC ALTA_GRADO_SERVICIO(2500,10000001,2,10000003);
EXEC ALTA_GRADO_SERVICIO(1000,10000001,2,10000004);
EXEC ALTA_GRADO_SERVICIO(2000,10000001,2,10000005);
EXEC ALTA_GRADO_SERVICIO(1000,10000001,2,10000006);
EXEC ALTA_GRADO_SERVICIO(340,10000001,2,10000007);
--PRIMARIA
EXEC ALTA_GRADO_SERVICIO(72000,10000002,1,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000002,1,10000002);
EXEC ALTA_GRADO_SERVICIO (2500,10000002,1,10000003);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,1,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000002,1,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,1,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000002,1,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000002,2,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000002,2,10000002);
EXEC ALTA_GRADO_SERVICIO (2500,10000002,2,10000003);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,2,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000002,2,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,2,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000002,2,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000002,3,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000002,3,10000002);
EXEC ALTA_GRADO_SERVICIO (2500,10000002,3,10000003);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,3,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000002,3,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,3,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000002,3,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000002,4,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000002,4,10000002);
EXEC ALTA_GRADO_SERVICIO (2500,10000002,4,10000003);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,4,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000002,4,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,4,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000002,4,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000002,5,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000002,5,10000002);
EXEC ALTA_GRADO_SERVICIO (2500,10000002,5,10000003);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,5,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000002,5,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,5,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000002,5,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000002,6,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000002,6,10000002);
EXEC ALTA_GRADO_SERVICIO (2500,10000002,6,10000003);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,6,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000002,6,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000002,6,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000002,6,10000007);

--SECUNDARIA
EXEC ALTA_GRADO_SERVICIO(72000,10000003,1,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000003,1,10000002);
EXEC ALTA_GRADO_SERVICIO (2700,10000003,1,10000003);
EXEC ALTA_GRADO_SERVICIO (1500,10000003,1,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000003,1,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000003,1,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000003,1,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000003,2,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000003,2,10000002);
EXEC ALTA_GRADO_SERVICIO (2700,10000003,2,10000003);
EXEC ALTA_GRADO_SERVICIO (1500,10000003,2,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000003,2,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000003,2,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000003,2,10000007);

EXEC ALTA_GRADO_SERVICIO(72000,10000003,3,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000003,3,10000002);
EXEC ALTA_GRADO_SERVICIO (2700,10000003,3,10000003);
EXEC ALTA_GRADO_SERVICIO (1500,10000003,3,10000004);
EXEC ALTA_GRADO_SERVICIO (2000,10000003,3,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000003,3,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000003,3,10000007);


--PREPARATORIA
EXEC ALTA_GRADO_SERVICIO(68000,10000004,1,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000004,1,10000002);
EXEC ALTA_GRADO_SERVICIO (2000,10000004,1,10000003);
EXEC ALTA_GRADO_SERVICIO (1200,10000004,1,10000004);
EXEC ALTA_GRADO_SERVICIO (5000,10000004,1,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000004,1,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000004,1,10000007);

EXEC ALTA_GRADO_SERVICIO(68000,10000004,2,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000004,2,10000002);
EXEC ALTA_GRADO_SERVICIO (2000,10000004,2,10000003);
EXEC ALTA_GRADO_SERVICIO (1200,10000004,2,10000004);
EXEC ALTA_GRADO_SERVICIO (5000,10000004,2,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000004,2,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000004,2,10000007);

EXEC ALTA_GRADO_SERVICIO(68000,10000004,3,10000001);
EXEC ALTA_GRADO_SERVICIO(10000,10000004,3,10000002);
EXEC ALTA_GRADO_SERVICIO (2000,10000004,3,10000003);
EXEC ALTA_GRADO_SERVICIO (1200,10000004,3,10000004);
EXEC ALTA_GRADO_SERVICIO (5000,10000004,3,10000005);
EXEC ALTA_GRADO_SERVICIO (1000,10000004,3,10000006);
EXEC ALTA_GRADO_SERVICIO  (340,10000004,3,10000007);

--/GRADO_SERVICIO
--LAST PROCEDURES
--RESPONSABLE
CREATE SEQUENCE AUTO_IDRESPONSABLE INCREMENT BY 1 MINVALUE 10000001;

CREATE OR REPLACE PROCEDURE ALTA_RESPONSABLE
(NOMBRERESP$ IN VARCHAR2,APELLIDOP$ IN VARCHAR2,APELLIDOM$ IN VARCHAR2,SEXO$ IN CHAR,EDAD$ IN NUMBER,PARENTESCO$ IN VARCHAR2,CALLE$ IN VARCHAR2,COLONIA$ IN VARCHAR2,NUMERO$ IN NUMBER,MOVIL$ IN NUMBER,TELEFONO$ IN NUMBER,HORARIO$ IN VARCHAR2)
AS
	IDRESPONSABLE_AUX  		NUMBER(8);
	AUTO_IDRESPONSABLE_AUX 	NUMBER(8);
BEGIN
	SELECT AUTO_IDRESPONSABLE.NEXTVAL INTO AUTO_IDRESPONSABLE_AUX FROM DUAL;
	INSERT INTO RESPONSABLE(IDRESPONSABLE,NOMBRERESP,APELLIDOP,APELLIDOM,SEXO,EDAD,PARENTESCO,CALLE,COLONIA,NUMERO,MOVIL)
	VALUES(AUTO_IDRESPONSABLE_AUX,NOMBRERESP$,APELLIDOP$,APELLIDOM$,SEXO$,EDAD$,PARENTESCO$,CALLE$,COLONIA$,NUMERO$,MOVIL$);
	
	SELECT IDRESPONSABLE INTO IDRESPONSABLE_AUX FROM RESPONSABLE WHERE IDRESPONSABLE=AUTO_IDRESPONSABLE_AUX;

	INSERT INTO TELEFONOHORARIO(IDRESPONSABLE,TELEFONO,HORARIO)
	VALUES(IDRESPONSABLE_AUX,TELEFONO$,HORARIO$);

	DBMS_OUTPUT.PUT_LINE('RESPONSABLE AGREGADO: '||IDRESPONSABLE_AUX);
END ALTA_RESPONSABLE;
/

CREATE OR REPLACE PROCEDURE AGREGAR_TELEFONO_RESPONSABLE(IDRESPONSABLE$ IN NUMBER,TELEFONO$ IN NUMBER,HORARIO$ IN VARCHAR2)
AS
BEGIN
	INSERT INTO TELEFONOHORARIO(IDRESPONSABLE,TELEFONO,HORARIO)VALUES(IDRESPONSABLE$,TELEFONO$,HORARIO$);
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL NUEVO NUMERO HA SIDO ACTUALIZADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END AGREGAR_TELEFONO_RESPONSABLE;
/

CREATE OR REPLACE PROCEDURE BAJA_RESPONSABLE(IDRESPONSABLE$ IN NUMBER)
AS
BEGIN
	DELETE FROM RESPONSABLE WHERE IDRESPONSABLE=IDRESPONSABLE$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL RESPONSABLE HA SIDO ELIMINADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END BAJA_RESPONSABLE;
/

CREATE OR REPLACE PROCEDURE ELIMINA_TELEFONO_RESPONSABLE(IDRESPONSABLE$ IN NUMBER,TELEFONO$ IN NUMBER)
AS
BEGIN
	DELETE FROM TELEFONOHORARIO WHERE IDRESPONSABLE=IDRESPONSABLE$ AND TELEFONO=TELEFONO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL NUMERO DEL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL NUMERO HA SIDO ELIMINADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END ELIMINA_TELEFONO_RESPONSABLE;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_RESPONSABLE(IDRESPONSABLE$ IN NUMBER,NOMBRERESP$ IN VARCHAR2,APELLIDOP$ IN VARCHAR2,APELLIDOM$ IN VARCHAR2,SEXO$ IN CHAR,EDAD$ IN NUMBER,PARENTESCO$ IN VARCHAR2,CALLE$ IN VARCHAR2,COLONIA$ IN VARCHAR2,NUMERO$ IN NUMBER,MOVIL$ IN NUMBER)
AS
BEGIN
	UPDATE RESPONSABLE SET NOMBRERESP=NOMBRERESP$,APELLIDOP=APELLIDOP$,APELLIDOM=APELLIDOM$,SEXO=SEXO$,EDAD=EDAD$,PARENTESCO=PARENTESCO$,CALLE=CALLE$,COLONIA=COLONIA$,NUMERO=NUMERO$,MOVIL=MOVIL$ WHERE IDRESPONSABLE=IDRESPONSABLE$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL RESPONSABLE HA SIDO ACTUALIZADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END ACTUALIZA_RESPONSABLE;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_HORARIO_TEL_RES(IDRESPONSABLE$ IN NUMBER,TELEFONO$ IN NUMBER,HORARIO$ IN VARCHAR2)
AS
BEGIN
	UPDATE TELEFONOHORARIO SET HORARIO=HORARIO$ WHERE IDRESPONSABLE=IDRESPONSABLE$ AND TELEFONO=TELEFONO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL NUMERO DEL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL NUMERO HA SIDO ACTUALIZADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END ACTUALIZA_HORARIO_TEL_RES;
/
--/RESPONSABLE
--TUTOR
CREATE OR REPLACE PROCEDURE ALTA_TUTOR(IDRESPONSABLE$ IN NUMBER,RFC$ IN CHAR)
AS
BEGIN
	INSERT INTO TUTOR(IDRESPONSABLE,RFC)VALUES(IDRESPONSABLE$,RFC$);
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTEN LOS DATOS DEL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL TUTOR HA SIDO AGREGADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END ALTA_TUTOR;
/

CREATE OR REPLACE PROCEDURE BAJA_TUTOR(RFC$ IN CHAR)
AS
BEGIN
	DELETE FROM TUTOR WHERE RFC=RFC$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTEN LOS DATOS DEL RESPONSABLE SOLICITADO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('EL TUTOR HA SIDO AGREGADO SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END BAJA_TUTOR;
/
--/TUTOR
--ALUMNO
CREATE SEQUENCE AUTO_IDALUMNO INCREMENT BY 1 MINVALUE 10000001;

CREATE OR REPLACE PROCEDURE ALTA_ALUMNO
(CURP$ IN VARCHAR2,NOMBREALU$ IN VARCHAR2,APELLIDOP$ IN VARCHAR2,APELLIDOM$ IN VARCHAR2,SEXO$ IN CHAR,FECHANAC$ IN DATE,ESTADO$ IN VARCHAR2,MUNICIPIO$ IN VARCHAR2,RFC$ IN CHAR)
AS
	AUTO_IDALUMNO_AUX 	NUMBER(8);
BEGIN
	IF TRUNC(MONTHS_BETWEEN(SYSDATE,FECHANAC$),2) > 24 THEN		
		SELECT AUTO_IDALUMNO.NEXTVAL INTO AUTO_IDALUMNO_AUX FROM DUAL;
		INSERT INTO ALUMNO(IDALUMNO,CURP,NOMBREALU,APELLIDOP,APELLIDOM,SEXO,FECHANAC,ESTADO,MUNICIPIO,RFC)
		VALUES(AUTO_IDALUMNO_AUX,CURP$,NOMBREALU$,APELLIDOP$,APELLIDOM$,SEXO$,FECHANAC$,ESTADO$,MUNICIPIO$,RFC$);
		DBMS_OUTPUT.PUT_LINE('ALUMNO AGREGADO: '||AUTO_IDALUMNO_AUX);
		COMMIT;
	ELSE
		DBMS_OUTPUT.PUT_LINE('FECHA DE NACIMIENTO INVALIDA');
	END IF;
END ALTA_ALUMNO;
/

CREATE OR REPLACE PROCEDURE BAJA_ALUMNO(IDALUMNO$ IN NUMBER)
AS
BEGIN
	DELETE FROM ALUMNO WHERE IDALUMNO=IDALUMNO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO SE ELIMINÓ ALUMNO ALGUNO');
	ELSE
		DBMS_OUTPUT.PUT_LINE('HA SIDO ELIMINADO EL ALUMNO');
		COMMIT;
	END IF;
END BAJA_ALUMNO;
/

CREATE OR REPLACE PROCEDURE ACTUALIZA_ALUMNO
(IDALUMNO$ IN NUMBER,CURP$ IN VARCHAR2,NOMBREALU$ IN VARCHAR2,APELLIDOP$ IN VARCHAR2,APELLIDOM$ IN VARCHAR2,SEXO$ IN CHAR,FECHANAC$ IN DATE,ESTADO$ IN VARCHAR2,MUNICIPIO$ IN VARCHAR2,RFC$ IN CHAR)
AS
BEGIN
	IF TRUNC(MONTHS_BETWEEN(SYSDATE,FECHANAC$),2) > 24 THEN	
		UPDATE ALUMNO SET CURP=CURP$,NOMBREALU=NOMBREALU$,APELLIDOP=APELLIDOP$,APELLIDOM=APELLIDOM$,SEXO=SEXO$,FECHANAC=FECHANAC$,ESTADO=ESTADO$,MUNICIPIO=MUNICIPIO$,RFC=RFC$
			WHERE IDALUMNO=IDALUMNO$;
		IF SQL%NOTFOUND THEN
			DBMS_OUTPUT.PUT_LINE('NO EXISTE EL ALUMNO A ACTUALIZAR');
		ELSE
			DBMS_OUTPUT.PUT_LINE('SE ACTUALIZÓ EL ALUMNO');
			COMMIT;
		END IF;
	ELSE
		DBMS_OUTPUT.PUT_LINE('FECHA DE NACIMIENTO INVALIDA');
	END IF;	
END ACTUALIZA_ALUMNO;
/

--/ALUMNO
--INSCRIPCION
CREATE SEQUENCE AUTO_IDINSCRIPCION INCREMENT BY 1 MINVALUE 10000001;

CREATE SEQUENCE AUTO_IDCARGO INCREMENT BY 1 MINVALUE 10000001;

CREATE OR REPLACE PROCEDURE INSCRIBIR_ALUMNO(IDALUMNO$ IN NUMBER,IDNIVEL$ IN NUMBER,IDGRADO$ IN NUMBER,MENSUALIDADES_COLEGIATURA$ IN NUMBER)
AS 
	ANO_ACTUAL 			NUMBER(5);
	ANO_SIG 			NUMBER(5);
	CICLOESCOLAR$  		VARCHAR2(45);
	FECHAINSCRIPCION$ 	DATE;

	TYPE CURSOR_GENERA_CARGOS IS REF CURSOR;
	VCURSOR 			CURSOR_GENERA_CARGOS;
	IDNIVEL_C$ 			NUMBER(8);
	IDGRADO_C$ 			NUMBER(8);
	IDSERVICIO_C$ 		NUMBER(8);
	PRECIO_C$ 			NUMBER(12,2);
	TIPO_C$ 				VARCHAR(45);
	IDINSCRIPCION_C$ 		NUMBER(8);
	CICLOESCOLAR_C$ 		VARCHAR(20);
	FECHAINSCRIPCION_C$ 	DATE;
	IDALUMNO_C$ 			NUMBER(8);

	FECHAVEN$ 		DATE;
	FRACCION$ 		NUMBER(12,2);	
BEGIN	
		SELECT EXTRACT(YEAR FROM SYSDATE) INTO ANO_ACTUAL FROM DUAL;
		SELECT EXTRACT(YEAR FROM (SELECT ADD_MONTHS(SYSDATE,12) FROM DUAL)) INTO ANO_SIG FROM DUAL;
		SELECT TO_DATE(SYSDATE,'DD/MM/YYYY') INTO FECHAINSCRIPCION$ FROM DUAL;
		CICLOESCOLAR$:=ANO_ACTUAL||'-'||ANO_SIG;
		INSERT INTO INSCRIPCION(IDINSCRIPCION,CICLOESCOLAR,FECHAINSCRIPCION,IDALUMNO,IDNIVEL,IDGRADO)
		VALUES(AUTO_IDINSCRIPCION.NEXTVAL,CICLOESCOLAR$,FECHAINSCRIPCION$,IDALUMNO$,IDNIVEL$,IDGRADO$);
		DBMS_OUTPUT.PUT_LINE('EL ALUMNO FUE INSCRITO');
		
		--GENERANDO CARGOS

		OPEN VCURSOR FOR
					SELECT IDNIVEL,IDGRADO,IDSERVICIO,PRECIO,TIPO,IDINSCRIPCION,CICLOESCOLAR,FECHAINSCRIPCION,IDALUMNO FROM NIVEL_GRADO NATURAL JOIN GRADO_SERVICIO NATURAL JOIN SERVICIO NATURAL JOIN INSCRIPCION 
					WHERE IDNIVEL=IDNIVEL$ AND IDGRADO=IDGRADO$ AND IDALUMNO=IDALUMNO$;
		
		LOOP
		
		FETCH VCURSOR INTO IDNIVEL_C$,IDGRADO_C$,IDSERVICIO_C$,PRECIO_C$,TIPO_C$,IDINSCRIPCION_C$,CICLOESCOLAR_C$,FECHAINSCRIPCION_C$,IDALUMNO_C$;
		EXIT WHEN VCURSOR%NOTFOUND;

		CASE IDSERVICIO_C$
						WHEN 10000001 THEN--COLEGIATURA
											FECHAVEN$:=SYSDATE;
											FECHAVEN$:=SYSDATE+40;
											CASE MENSUALIDADES_COLEGIATURA$
												WHEN  1 THEN
															FECHAVEN$:=SYSDATE;
															FECHAVEN$:=SYSDATE+35;
															PRECIO_C$:=PRECIO_C$*0.8;
															INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
															VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
												WHEN  2 THEN
															FECHAVEN$:=SYSDATE;
															PRECIO_C$:=PRECIO_C$*0.85;
															FRACCION$:=PRECIO_C$/2;
															FOR I IN 1..2 LOOP	
																FECHAVEN$:=SYSDATE+(35*I);
																INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
																VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,FRACCION$,2,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
															END LOOP;
												WHEN  3 THEN
															FECHAVEN$:=SYSDATE;
															PRECIO_C$:=PRECIO_C$*0.9;
															FRACCION$:=PRECIO_C$/3;
															FOR I IN 1..3 LOOP	
																FECHAVEN$:=SYSDATE+(35*I);
																INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
																VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,FRACCION$,3,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
															END LOOP;
												WHEN  6 THEN
															FECHAVEN$:=SYSDATE;
															PRECIO_C$:=PRECIO_C$*0.94;
															FRACCION$:=PRECIO_C$/6;
															FOR I IN 1..6 LOOP	
																FECHAVEN$:=SYSDATE+(35*I);
																INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
																VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,FRACCION$,6,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
															END LOOP;
												WHEN 10 THEN
															FECHAVEN$:=SYSDATE;
															PRECIO_C$:=PRECIO_C$*0.97;
															FRACCION$:=PRECIO_C$/10;
															FOR I IN 1..10 LOOP	
																FECHAVEN$:=SYSDATE+(35*I);
																INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
																VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,FRACCION$,10,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
															END LOOP;
												WHEN 12 THEN
															FECHAVEN$:=SYSDATE;
															FRACCION$:=PRECIO_C$/12;
															FOR I IN 1..12 LOOP	
																FECHAVEN$:=SYSDATE+(35*I);
																INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
																VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,FRACCION$,12,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);		
															END LOOP;
												ELSE DBMS_OUTPUT.PUT_LINE('VALOR DE MENSUALIDADES NO PERMITIDO, DEFAULT 1 ');
															FECHAVEN$:=SYSDATE;
															FECHAVEN$:=SYSDATE+35;
															PRECIO_C$:=PRECIO_C$*0.8;
															INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
															VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
											END CASE;										
						
						WHEN 10000002 THEN--INSCRIPCION
											FECHAVEN$:=SYSDATE;
											FECHAVEN$:=SYSDATE+35;
											INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
											VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
						WHEN 10000003 THEN--MATERIAL ESCOLAR
											FECHAVEN$:=SYSDATE;
											FECHAVEN$:=SYSDATE+35;
											INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
											VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
						WHEN 10000004 THEN--UNIFORME
											FECHAVEN$:=SYSDATE;
											FECHAVEN$:=SYSDATE+35;
											INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
											VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
						WHEN 10000005 THEN--LIBROS
											FECHAVEN$:=SYSDATE;
											FECHAVEN$:=SYSDATE+35;
											INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
											VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
						WHEN 10000006 THEN--SEGURO MEDICO
											FECHAVEN$:=SYSDATE;
											FECHAVEN$:=SYSDATE+35;
											INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
											VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,1,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
						WHEN 10000007 THEN--TRANSPORTE
											FECHAVEN$:=SYSDATE;
											FOR I IN 1..12 LOOP	
																FECHAVEN$:=SYSDATE+(32*I);
																INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
																VALUES(AUTO_IDCARGO.NEXTVAL,SYSDATE,FECHAVEN$,NULL,PRECIO_C$,12,NULL,0,NULL,NULL,IDINSCRIPCION_C$,IDSERVICIO_C$);	
															END LOOP;
		END CASE;
	
	END LOOP;

END INSCRIBIR_ALUMNO;
/



CREATE OR REPLACE PROCEDURE DAR_DE_BAJA_ALUMNO(IDINSCRIPCION$ IN NUMBER)
AS
BEGIN
	DELETE FROM INSCRIPCION WHERE IDINSCRIPCION=IDINSCRIPCION$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE LA INSCRIPCION SOLICITADA');
	ELSE
		DBMS_OUTPUT.PUT_LINE('LA INSCRIPCION HA SIDO ELIMINADA SATISFACTORIAMENTE');
		COMMIT;
	END IF;
END DAR_DE_BAJA_ALUMNO;
/

--/INSCRIPCION


--/LAST PROCEDURES

CREATE OR REPLACE FUNCTION GET_FECHA_ACTUAL(FECHA$ DATE)
RETURN DATE
IS
	CAD1$ VARCHAR2(8);
	FECHA_ACTUAL$ DATE;	
BEGIN
	CAD1$:=TO_CHAR(FECHA$);
	FECHA_ACTUAL$:=TO_DATE(CAD1$);
RETURN(FECHA_ACTUAL$);
END GET_FECHA_ACTUAL;
/

CREATE SEQUENCE AUTO_IDDESCUENTO
INCREMENT BY 1 MINVALUE 10000001;

--PROCEDIMIENTO LLAMADO POR PAGAR_CARGO
CREATE OR REPLACE PROCEDURE GENERAR_CVS
AS
	CURSOR CURSOR_TABLA_CARGO$ IS
	SELECT * FROM CARGO ORDER BY IDCARGO;

	CARGO_ACTUAL$ NUMBER(8);
	SUBCARGO$ NUMBER(8);
	FECHACARGO$ DATE;
	IMPORTE$ NUMBER(12,2);
	IDCARGO_AUTO$ PLS_INTEGER;

BEGIN
	
	FOR C_CARGO$ IN CURSOR_TABLA_CARGO$ LOOP
		IF (SYSDATE >= C_CARGO$.FECHAVEN) AND (C_CARGO$.ABONO = 0) THEN

			IF (C_CARGO$.CVS = 'SI') THEN
				DBMS_OUTPUT.PUT_LINE('');
			ELSE

				CARGO_ACTUAL$:=C_CARGO$.IDCARGO;
				SELECT COUNT(*) INTO SUBCARGO$ FROM CARGO WHERE CARGO=CARGO_ACTUAL$;

				IF SUBCARGO$=0 THEN
					
					IDCARGO_AUTO$:=AUTO_IDCARGO.NEXTVAL;
					FECHACARGO$:=C_CARGO$.FECHAVEN+10;
					IMPORTE$:=C_CARGO$.IMPORTE*0.05;
					INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
					VALUES(IDCARGO_AUTO$,FECHACARGO$,C_CARGO$.FECHAVEN,NULL,IMPORTE$,0,0,0,'SI',CARGO_ACTUAL$,C_CARGO$.IDINSCRIPCION,C_CARGO$.IDSERVICIO);

				END IF;

			END IF;

		END IF;

	END LOOP;

END GENERAR_CVS;
/

--PROCEDIMIENTO LLAMADO POR PAGAR_CARGO
CREATE OR REPLACE PROCEDURE PROC_AFTER_GENERA_DESCUENTO(IDCARGO$ IN NUMBER)
AS
	FECHACARGO$ 	DATE;
	FECHAVEN$ 	DATE;
	FECHAPAGO$ 	DATE;
	IMPORTE$ 	NUMBER(12,2);
	NUMERO_PAGOS$ NUMBER(2);
	PAGO$ 		 NUMBER(3);
	ABONO$ 		NUMBER(12,2);
	CVS$ 		CHAR(2);
	CARGO$ 		NUMBER(8);
	IDINSCRIPCION$ NUMBER(8);
	IDSERVICIO$    NUMBER(8);

	ABONADO$ NUMBER(11,2);

	TOTAL$	NUMBER(12,2);
	IDDESCUENTO_AUTO$ PLS_INTEGER;
	IDCARGO_AUTO$ PLS_INTEGER;
	MONTODESCUENTO$ NUMBER(12,2);
	NUEVO_IMPORTE$ NUMBER(12,2);
	
BEGIN

	SELECT 	FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO
	 INTO FECHACARGO$,FECHAVEN$,FECHAPAGO$,IMPORTE$,NUMERO_PAGOS$,PAGO$,ABONO$,CVS$,CARGO$,IDINSCRIPCION$,IDSERVICIO$
	 FROM CARGO WHERE IDCARGO=IDCARGO$;

	TOTAL$:= IMPORTE$ - ABONO$;
	--IDDESCUENTO$:=AUTO_IDDESCUENTO.NEXTVAL;
	MONTODESCUENTO$:=ABONO$ * 0.05;
	NUEVO_IMPORTE$:=IMPORTE$-ABONO$;

	IF TOTAL$ <= 0 THEN--SI SE SALDÒ TODO EL IMPORTE DEL CARGO
		DBMS_OUTPUT.PUT_LINE('PAGÒ POR COMPLETO');

		IF GET_FECHA_ACTUAL(SYSDATE) <= FECHACARGO$ THEN --SI SE PAGA CON TIEMPO ANTICIPADO
			IF CVS$='SI' THEN --SI SE TRATA DE UN CARGO POR SERVICIO VENCIDO NO PUEDE HABER DESCUENTO
				DBMS_OUTPUT.PUT_LINE('NO SE GENERÒ DESCUENTO');
			ELSE --SI NO  ES UN CARGO POR SERVICIO VENCIDO SÌ HAY DESCUENTO
				IDDESCUENTO_AUTO$:=AUTO_IDDESCUENTO.NEXTVAL;
				INSERT INTO DESCUENTO(IDDESCUENTO,IDCARGO,FECHADESC,IMPORTE,APLICADO,CARGOAPLICADO,REMUNERADO)
				VALUES(IDDESCUENTO_AUTO$,IDCARGO$,SYSDATE,MONTODESCUENTO$,'NO',NULL,'NO');
				DBMS_OUTPUT.PUT_LINE('SE SALDÒ COMPLETAMENTE EL CARGO: '||IDCARGO$||' Y SE GENERÒ EL DESCUENTO: '||IDDESCUENTO_AUTO$||' POR UN MONTO DE: '||MONTODESCUENTO$);
			END IF;
		ELSE --SI NO SE PAGA CON TIEMPO ANTICIPADO
			DBMS_OUTPUT.PUT_LINE('PAGÒ DESPÙES DE FECHACARGO');
		END IF;

	ELSE --SI SE PAGA PARCIALMENTE

		IF GET_FECHA_ACTUAL(SYSDATE) <= FECHACARGO$ THEN --SI SE PAGA CON TIEMPO ANTICIPADO
			IF CVS$='SI' THEN --SI SE TRATA DE UN CARGO POR SERVICIO VENCIDO NO PUEDE HABER DESCUENTO
				DBMS_OUTPUT.PUT_LINE('NO SE GENERÒ DESCUENTO');
				DBMS_OUTPUT.PUT_LINE('SE SALDÒ PARCIALMENTE EL CARGO POR VENCIMIENTO: '||IDCARGO$);

				IDCARGO_AUTO$:=AUTO_IDCARGO.NEXTVAL;
				INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
				VALUES(IDCARGO_AUTO$,SYSDATE,FECHAVEN$,NULL,NUEVO_IMPORTE$,0,0,0,'SI',IDCARGO$,IDINSCRIPCION$,IDSERVICIO$);						

				DBMS_OUTPUT.PUT_LINE('SE GENERÒ EL SUBCARGO: '||IDCARGO_AUTO$);				
			ELSE --SI NO  ES UN CARGO POR SERVICIO VENCIDO SÌ HAY DESCUENTO
				IDDESCUENTO_AUTO$:=AUTO_IDDESCUENTO.NEXTVAL;
				INSERT INTO DESCUENTO(IDDESCUENTO,IDCARGO,FECHADESC,IMPORTE,APLICADO,CARGOAPLICADO,REMUNERADO)
				VALUES(IDDESCUENTO_AUTO$,IDCARGO$,SYSDATE,MONTODESCUENTO$,'NO',NULL,'NO');
				DBMS_OUTPUT.PUT_LINE('SE SALDÒ PARCIALMENTE EL CARGO: '||IDCARGO$||' Y SE GENERÒ EL DESCUENTO: '||IDDESCUENTO_AUTO$||' POR UN MONTO DE: '||MONTODESCUENTO$);

				IDCARGO_AUTO$:=AUTO_IDCARGO.NEXTVAL;
				INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
				VALUES(IDCARGO_AUTO$,SYSDATE,FECHAVEN$,NULL,NUEVO_IMPORTE$,0,0,0,NULL,IDCARGO$,IDINSCRIPCION$,IDSERVICIO$);						

				DBMS_OUTPUT.PUT_LINE('SE GENERÒ EL SUBCARGO: '||IDCARGO_AUTO$);
			END IF;
		ELSE --SI NO SE PAGA CON TIEMPO ANTICIPADO
--MODIFICANDO

			IF CVS$='SI' THEN --SI SE TRATA DE UN CARGO POR SERVICIO VENCIDO NO PUEDE HABER DESCUENTO
				DBMS_OUTPUT.PUT_LINE('NO SE GENERÒ DESCUENTO');
				DBMS_OUTPUT.PUT_LINE('SE SALDÒ PARCIALMENTE EL CARGO POR VENCIMIENTO: '||IDCARGO$);

				IDCARGO_AUTO$:=AUTO_IDCARGO.NEXTVAL;
				INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
				VALUES(IDCARGO_AUTO$,SYSDATE,FECHAVEN$,NULL,NUEVO_IMPORTE$,0,0,0,'SI',IDCARGO$,IDINSCRIPCION$,IDSERVICIO$);						

				DBMS_OUTPUT.PUT_LINE('SE GENERÒ EL SUBCARGO: '||IDCARGO_AUTO$);				
			ELSE --SI NO  ES UN CARGO POR SERVICIO VENCIDO
				DBMS_OUTPUT.PUT_LINE('NO SE GENERÒ DESCUENTO');
				DBMS_OUTPUT.PUT_LINE('SE SALDÒ PARCIALMENTE EL CARGO: '||IDCARGO$);

				IDCARGO_AUTO$:=AUTO_IDCARGO.NEXTVAL;
				INSERT INTO CARGO(IDCARGO,FECHACARGO,FECHAVEN,FECHAPAGO,IMPORTE,NUMERO_PAGOS,PAGO,ABONO,CVS,CARGO,IDINSCRIPCION,IDSERVICIO)
				VALUES(IDCARGO_AUTO$,SYSDATE,FECHAVEN$,NULL,NUEVO_IMPORTE$,0,0,0,NULL,IDCARGO$,IDINSCRIPCION$,IDSERVICIO$);						

				DBMS_OUTPUT.PUT_LINE('SE GENERÒ EL SUBCARGO: '||IDCARGO_AUTO$);
			END IF;

		END IF;

	END IF;


END PROC_AFTER_GENERA_DESCUENTO;
/

CREATE OR REPLACE PROCEDURE PAGAR_CARGO(IDCARGO$ IN NUMBER,ABONO$ IN NUMBER)
AS
	FECHAPAGO$ DATE:=SYSDATE;
	ABONADO$ NUMBER(11,2);
	IMPORTE$ NUMBER(11,2);
	PARAMETRO_ABONO$ NUMBER(11,2);
BEGIN
	GENERAR_CVS;--ANTES QUE NADA, SE CORROBORA QUE NO SE TENGA QUE CALCULAR NUEVOS CARGOS POR CVS
	SELECT ABONO,IMPORTE INTO ABONADO$,IMPORTE$ FROM CARGO WHERE IDCARGO=IDCARGO$;
	IF SQL%NOTFOUND THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTE EL CARGO A SALDAR');
	ELSE
		IF ABONADO$ > 0 THEN --SÒLO SE PUEDE ABONAR UNA ÙNICA VEZ	
			DBMS_OUTPUT.PUT_LINE('ESTE CARGO YA HA SIDO ABONADO TOTAL O PARCIALMENTE');
		ELSE
			PARAMETRO_ABONO$:=ABONO$;
			IF ABONO$ > IMPORTE$ THEN
				DBMS_OUTPUT.PUT_LINE('EL ABONO EXCEDE AL IMPORTE, SOLO SE PAGARA EL IMPORTE');
				PARAMETRO_ABONO$:=IMPORTE$;
			END IF;

			UPDATE CARGO SET ABONO=PARAMETRO_ABONO$, FECHAPAGO=FECHAPAGO$ WHERE IDCARGO=IDCARGO$;
			DBMS_OUTPUT.PUT_LINE('SE SALDÒ EL CARGO');
			COMMIT;
			PROC_AFTER_GENERA_DESCUENTO(IDCARGO$);--LLAMA AL PROCEDIMIENTO QUE GENARA LOS DESCUENTOS
		END IF;
	END IF;
END PAGAR_CARGO;
/

--******************* REMUNERAR DESCUENTO
CREATE OR REPLACE PROCEDURE REMUNERAR_DESC(IDDESCUENTO$ IN NUMBER)
AS
	EXISTEN_REGS$ NUMBER(8);
	EXISTE_DESC$ NUMBER(8);
	YA_REMUNERADO$ NUMBER(8);
	IMPORTE$ NUMBER(12,2);
BEGIN
	GENERAR_CVS;--ANTES QUE NADA, SE CORROBORA QUE NO SE TENGA QUE CALCULAR NUEVOS CARGOS POR CVS
	SELECT COUNT(*) INTO EXISTEN_REGS$ FROM DESCUENTO;
	IF EXISTEN_REGS$ = 0 THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTEN DESCUENTOS');
	ELSE
		SELECT COUNT(*) INTO EXISTE_DESC$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$;
		IF EXISTE_DESC$=0 THEN
			DBMS_OUTPUT.PUT_LINE('NO EXISTE EL DESCUENTO EN CUESTION');
		ELSE -- EL IDDESCUENTO EXISTE
			SELECT COUNT(*) INTO YA_REMUNERADO$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$ AND (REMUNERADO ='SI' OR APLICADO='SI');
			IF YA_REMUNERADO$>0 THEN
				DBMS_OUTPUT.PUT_LINE('EL DESCUENTO YA HA SIDO REMUNERADO O APLICADO CON ANTERIORIDAD');
			ELSE--SI NO HA SIDO REMUNERADO
				UPDATE DESCUENTO SET REMUNERADO='SI' WHERE IDDESCUENTO=IDDESCUENTO$;
				SELECT IMPORTE INTO IMPORTE$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$;
				COMMIT;
				DBMS_OUTPUT.PUT_LINE('EL DESCUENTO DE $'||IMPORTE$||' HA SIDO REMUNERADO');
			END IF;			
		END IF;		
	END IF;
END REMUNERAR_DESC;
/

--******************************************

CREATE OR REPLACE PROCEDURE APLICAR_DESCUENTO(IDDESCUENTO$ IN NUMBER,CARGOAPLICADO$ IN NUMBER)
AS
	EXISTEN_REGS$ NUMBER(8);
	EXISTE_DESC$ NUMBER(8);
	EXISTE_CARGO$ NUMBER(8);
	YA_APLICADO$ NUMBER(8);
	IMPORTE$ NUMBER(12,2);--CORRESPONDE AL IMPORTE REGISTRADO EN TABLA DESCUENTO
	IDINSCRIPCION$ NUMBER(8);
	IDCARGO$ NUMBER(8);
	IDINSCRIPCION2$ NUMBER(8);

	FECHAPAGO$ DATE:=SYSDATE;
	ABONADO$ NUMBER(11,2);
	IMPORTE2$ NUMBER(11,2);--CORRESPONDE AL IMPORTE REGISTRADO EN TABLA CARGO
	PARAMETRO_ABONO$ NUMBER(11,2);

BEGIN
	GENERAR_CVS;--ANTES QUE NADA, SE CORROBORA QUE NO SE TENGA QUE CALCULAR NUEVOS CARGOS POR CVS
	SELECT COUNT(*) INTO EXISTEN_REGS$ FROM DESCUENTO;
	IF EXISTEN_REGS$ = 0 THEN
		DBMS_OUTPUT.PUT_LINE('NO EXISTEN DESCUENTOS');
	ELSE
		SELECT COUNT(*) INTO EXISTE_DESC$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$;
		IF EXISTE_DESC$=0 THEN
			DBMS_OUTPUT.PUT_LINE('NO EXISTE EL DESCUENTO EN CUESTION');
		ELSE -- EL IDDESCUENTO EXISTE
			SELECT COUNT(*) INTO YA_APLICADO$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$ AND (REMUNERADO='SI' OR APLICADO='SI');
			IF YA_APLICADO$>0 THEN
				DBMS_OUTPUT.PUT_LINE('EL DESCUENTO YA HA SIDO REMUNERADO O APLICADO CON ANTERIORIDAD');
			ELSE--SI NO HA SIDO REMUNERADO
				--SELECT COUNT(*) INTO EXISTE_CARGO$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$;
				--###
				SELECT IDCARGO INTO IDCARGO$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$;--EL CARGO QUE GENERO EL DESCUENTO
				SELECT COUNT(*) INTO EXISTE_CARGO$ FROM CARGO WHERE IDCARGO=CARGOAPLICADO$;--EL CARGO AL QUE SE LE APLICARA DESCUENTO
				IF EXISTE_CARGO$=0 THEN
					DBMS_OUTPUT.PUT_LINE('NO EXISTE EL CARGO EN CUESTION');
				ELSE 	--SI--EXISTE EL CARGO EN LA TABLA CARGO


					SELECT IDINSCRIPCION INTO IDINSCRIPCION$ FROM CARGO WHERE IDCARGO=IDCARGO$;--LA INSCRIPCION QUE GENERO AL DESCUENTO
					SELECT IDINSCRIPCION INTO IDINSCRIPCION2$ FROM CARGO WHERE IDCARGO=CARGOAPLICADO$;--LA INSC QUE GNRO EL CARGO QUE SE DESEA APLICAR DESC

					IF IDINSCRIPCION$=IDINSCRIPCION2$ THEN --SI PERTENECE A LA MISMA INSCRIPCION

						SELECT ABONO,IMPORTE INTO ABONADO$,IMPORTE2$ FROM CARGO WHERE IDCARGO=CARGOAPLICADO$;
						IF SQL%NOTFOUND THEN
							DBMS_OUTPUT.PUT_LINE('NO EXISTE EL CARGO A SALDAR');
						ELSE
							IF ABONADO$ > 0 THEN --SÒLO SE PUEDE ABONAR UNA ÙNICA VEZ	
								DBMS_OUTPUT.PUT_LINE('ESTE CARGO YA HA SIDO ABONADO TOTAL O PARCIALMENTE');
							ELSE


								UPDATE DESCUENTO SET APLICADO='SI',CARGOAPLICADO=CARGOAPLICADO$ WHERE IDDESCUENTO=IDDESCUENTO$;
								SELECT IMPORTE INTO IMPORTE$ FROM DESCUENTO WHERE IDDESCUENTO=IDDESCUENTO$;
								
								PARAMETRO_ABONO$:=IMPORTE$;
								IF IMPORTE$ > IMPORTE2$ THEN
									DBMS_OUTPUT.PUT_LINE('EL MONTO DEL DESCUENTO EXCEDE AL IMPORTE DEL CARGO, SOLO SE PAGARA EL IMPORTE');
									PARAMETRO_ABONO$:=IMPORTE2$;
								END IF;

								UPDATE CARGO SET ABONO=PARAMETRO_ABONO$, FECHAPAGO=FECHAPAGO$ WHERE IDCARGO=CARGOAPLICADO$;
								DBMS_OUTPUT.PUT_LINE('SE APLICO EL DESCUENTO');
								COMMIT;
								PROC_AFTER_GENERA_DESCUENTO(CARGOAPLICADO$);--LLAMA AL PROCEDIMIENTO QUE GENARA LOS DESCUENTOS
							END IF;
						END IF;
					ELSE 	--NO SE TRATA DE LA MISMA INSCRIPCION
						DBMS_OUTPUT.PUT_LINE('NO SE`PUEDE APLICAR EL DESCUENTO, DEBIDO A QUE EL CARGO PERTENECE A OTRA INSCRIPCION');
					END IF;

				END IF;

			END IF;			
		END IF;		
	END IF;
EXCEPTION
	WHEN NO_DATA_FOUND THEN
		DBMS_OUTPUT.PUT_LINE('INGRESO CARGO O DESCUENTO NO VALIDOS');

END APLICAR_DESCUENTO;
/

--###############################################3
CREATE OR REPLACE PROCEDURE ALTA_ALUMNO_RESPONSABLE(IDALUMNO$ IN NUMBER,IDRESPONSABLE$ IN NUMBER)
AS 	
	REGS_ALUMNO$ NUMBER(8);
	REGS_RESPONSABLE$ NUMBER(8);
	YA_EXISTE$ NUMBER(8);
	EXITE_ALUMNO$ NUMBER(8);
	EXISTE_RESP$ NUMBER(8);
BEGIN
	SELECT COUNT(*) INTO REGS_ALUMNO$ FROM ALUMNO;
	SELECT COUNT(*) INTO REGS_RESPONSABLE$ FROM RESPONSABLE;
	IF (REGS_ALUMNO$ > 0) AND (REGS_RESPONSABLE$ > 0) THEN
		SELECT COUNT(*) INTO YA_EXISTE$ FROM ALUMNO_RESPONSABLE WHERE IDALUMNO=IDALUMNO$ AND IDRESPONSABLE=IDRESPONSABLE$;
		IF YA_EXISTE$=0 THEN --SI NO EXISTE REGISTRO DUPLICADO
			SELECT COUNT(*) INTO EXITE_ALUMNO$ FROM ALUMNO WHERE IDALUMNO=IDALUMNO$;
			SELECT COUNT(*) INTO EXISTE_RESP$ FROM RESPONSABLE WHERE IDRESPONSABLE=IDRESPONSABLE$;
			IF EXITE_ALUMNO$=0 OR EXISTE_RESP$=0 THEN --SI ALGUNO NO EXISTE
				DBMS_OUTPUT.PUT_LINE('EL ALUMNO O RESPONSABLE NO EXISTEN EN TABLAS PADRE');
			ELSE
				INSERT INTO ALUMNO_RESPONSABLE(IDALUMNO,IDRESPONSABLE) VALUES(IDALUMNO$,IDRESPONSABLE$);
				DBMS_OUTPUT.PUT_LINE('SE AGREGO EL REGISTRO');
				COMMIT;
			END IF;
		ELSE 	--SI YA EXISTE
			DBMS_OUTPUT.PUT_LINE('EL REGISTRO YA EXISTE');
		END IF;
	ELSE
		DBMS_OUTPUT.PUT_LINE('NO HAY REGISTROS PADRES EN TABLAS ALUMNO O RESPONSABLE');
	END IF;
EXCEPTION
	WHEN NO_DATA_FOUND THEN
		DBMS_OUTPUT.PUT_LINE('REGISTRO NO ALMACENADO');
END ALTA_ALUMNO_RESPONSABLE;
/
--*******************
CREATE OR REPLACE PROCEDURE BAJA_ALUMNO_RESPONSABLE(IDALUMNO$ IN NUMBER,IDRESPONSABLE$ IN NUMBER)
AS 	
	EXISTE_ALU_RESP$ NUMBER(8);
	TABLA_NO_VACIA$ NUMBER(8);
BEGIN
	SELECT COUNT(*) INTO TABLA_NO_VACIA$ FROM ALUMNO_RESPONSABLE;
	IF TABLA_NO_VACIA$=0 THEN --TABLA VACIA
		DBMS_OUTPUT.PUT_LINE('NO EXISTEN REGISTROS');
	ELSE --TABLA NO VACIA
		SELECT COUNT(*) INTO EXISTE_ALU_RESP$ FROM ALUMNO_RESPONSABLE WHERE IDALUMNO=IDALUMNO$ AND IDRESPONSABLE=IDRESPONSABLE$;
		IF EXISTE_ALU_RESP$=0 THEN --SI NO EXISTE EL REGISTRO
			DBMS_OUTPUT.PUT_LINE('NO EXISTE EL REGISTRO');
		ELSE
			DELETE FROM ALUMNO_RESPONSABLE WHERE IDALUMNO=IDALUMNO$ AND IDRESPONSABLE=IDRESPONSABLE$;
			DBMS_OUTPUT.PUT_LINE('SE ELIMINO EL REGISTRO');
			COMMIT;			
		END IF;

	END IF;

EXCEPTION
	WHEN NO_DATA_FOUND THEN
		DBMS_OUTPUT.PUT_LINE('REGISTRO NO ELIMINADO');
END BAJA_ALUMNO_RESPONSABLE;
/

--*******************
--**CONSULTA 2
CREATE OR REPLACE PROCEDURE VER_DEUDA_TOTAL_TUTOR(RFC$ IN CHAR)
AS
	DEUDA_TUTOR$ NUMBER(12,2);
BEGIN
	SELECT SUM(IMPORTE) INTO  DEUDA_TUTOR$ FROM (((TUTOR NATURAL JOIN ALUMNO) NATURAL JOIN INSCRIPCION) NATURAL JOIN CARGO) WHERE RFC=RFC$ AND ABONO=0;
	DBMS_OUTPUT.PUT_LINE('lA DEUDA DEL TUTOR ASCIENDE A: '||DEUDA_TUTOR$);
END VER_DEUDA_TOTAL_TUTOR;
/

--********************
--**CONSULTA 3
CREATE OR REPLACE PROCEDURE CARGOS_PENDIENTES_TUTOR_ALU(RFC$ IN CHAR,IDALUMNO$ IN NUMBER)
AS
	CARGOS_PEND$ NUMBER(12,2);
BEGIN
	SELECT COUNT(*)  INTO CARGOS_PEND$ FROM (((TUTOR NATURAL JOIN ALUMNO) NATURAL JOIN INSCRIPCION) NATURAL JOIN CARGO) WHERE RFC=RFC$ AND ABONO=0 AND IDALUMNO=IDALUMNO$;
	DBMS_OUTPUT.PUT_LINE('EL NUMERO DE CARGOS PENDIENTES DEL TUTOR POR ESTE ALUMNO ES: '||CARGOS_PEND$);
END CARGOS_PENDIENTES_TUTOR_ALU;
/


--**********************
--VISTAS--
CREATE VIEW ALUMNOS_INSCRITOS AS SELECT CICLOESCOLAR CICLO_ESCOLAR,COUNT(*) ALUMNOS_INSCRITOS FROM INSCRIPCION GROUP BY CICLOESCOLAR;

COMMIT;
EXIT